MacHack 2001/MacHack 2001.toast/pc/The Hacks/SpellCompositor/SpellBook.java

Java Source | 2001-06-23 | 6.7 KB | 263 lines

/*
    SpellBook
        - Data-structure for the collection of SpellRecords and SpellRegisters

    Written by Scott C. Ziegler for use with Simulcra RPG and AD&D.



    vers. history:
        09.07.00 - achieved a syntactically correct version

    Work Needed:


    Work Completed:
        - added an add and remove function



*/

/*
This file and its intellectual contents are considered property of the creator and are to be treated as such with respect to use in other applications.  Any use of this software for any purpose whatsoever must have explicit permission from the author of the file.  This code is part of an ongoing development process for future possible products, and so is considered private property.
Do not use without permission.  Author: Scott C. Ziegler <[e-mail]>
*/

package Arcana;

import java.awt.*;
import javax.swing.*;

import java.io.*;
import java.util.*;

public class SpellBook implements java.io.Serializable {

    // Data Members

    String        Name;
    String        Creator;
    String        Owner;

    Vector[]                SpellRecordArray = new Vector[9];
    SpellRegisterVector[]    SpellRegisterArray = new SpellRegisterVector[9];

    int            noOfSpellsInBook;
    int            maxNoOfSpells;


    // Methods

    // Constructors

    public SpellBook() {
        Name = "";
        Creator = "";
        Owner = "";

        //System.out.println("before init loop");
        for (int i=0; i < 9; i++) {
            SpellRecordArray[i] = new Vector(50);
            SpellRegisterArray[i] = new SpellRegisterVector();
            }
        //System.out.println("after init loop");

        noOfSpellsInBook = 0;
        maxNoOfSpells = 1024;
        }

    public SpellBook(SpellBook spellBook) {
        Name = spellBook.getName();
        Creator = spellBook.getCreator();
        Owner = spellBook.getOwner();

        for (int i=0; i < 9; i++) {
            SpellRecordArray[i] = spellBook.getSpellRecordVectorByIndex(i);
            SpellRegisterArray[i] = spellBook.getSpellRegisterVectorByIndex(i);
            }

        noOfSpellsInBook = spellBook.getNoOfSpellsInBook();
        maxNoOfSpells = spellBook.getMaxNoOfSpells();
        }

    // Mutators

    public void setName(String name) {
        Name = name;
        }

    public void setCreator(String create) {
        Creator = create;
        }

    public void setOwner(String owner) {
        Owner = owner;
        }

    // WARNING: By level! (not index)
    // not used much?
    public void setSpellRecordVector(Vector newRecordVec, int level) {
        SpellRecordArray[level - 1] = newRecordVec;
        }

    public void setSpellRecordVectorByIndex(Vector newRecordVec, int index) {
        SpellRecordArray[index] = newRecordVec;
        }

    public void setSpellRecordArray(Vector[] spellVecArray) {
        for (int i=0; i < 9; i++) {
            SpellRecordArray[i] = spellVecArray[i];
            }
        }

    public void setSpellRegisterVector(SpellRegisterVector newRegisterVec, int level) {
        SpellRegisterArray[level - 1] = newRegisterVec;
        }

    public void setSpellRegisterVectorByIndex(SpellRegisterVector newRegisterVec, int index) {
        SpellRegisterArray[index] = newRegisterVec;
        }

    public void setSpellRegisterArray(SpellRegisterVector[] spellVecArray) {
        for (int i=0; i < 9; i++) {
            SpellRegisterArray[i] = spellVecArray[i];
            }
        }

    protected void setNoOfSpellsInBook(int noInBook) {
        noOfSpellsInBook = noInBook;
        }

    public void setMaxNoOfSpells(int maxNoSpells) {
        maxNoOfSpells = maxNoSpells;
        }

    // Selectors

    public String getName() {
        return Name;
        }

    public String getCreator() {
        return Creator;
        }

    public String getOwner() {
        return Owner;
        }

    // WARNING: this is by Level
    public Vector getSpellRecordVector(int level) {
        return SpellRecordArray[level - 1];
        }

    public Vector getSpellRecordVectorByIndex(int index) {
        return SpellRecordArray[index];
        }

    public SpellRegisterVector getSpellRegisterVector(int level) {
        return SpellRegisterArray[level - 1];
        }

    public SpellRegisterVector getSpellRegisterVectorByIndex(int index) {
        return SpellRegisterArray[index];
        }

    public Vector[] getSpellRecordArray() {
        return SpellRecordArray;
        }

    public SpellRegisterVector[] getSpellRegisterArray() {
        return SpellRegisterArray;
        }

    public int getNoOfSpellsInBook() {
        return noOfSpellsInBook;
        }

    public int getMaxNoOfSpells() {
        return maxNoOfSpells;
        }

    // Methods of importantcy

    // might need to rework the SpellRegister creation
    public void addSpellRecord(SpellRecord newSpell) {
        if ((noOfSpellsInBook + 1) < maxNoOfSpells) {
            String spName = newSpell.getName();
            // determine level of spell
            int levelOfSpell = newSpell.getLevel();
            // if spell of same name is not in book...
            if (findSpell(spName, levelOfSpell).getName().compareTo("Untitled") == 0) {
                // get that level's vector for addition to
                Vector spellVector = getSpellRecordVector(levelOfSpell);
                spellVector.addElement(newSpell);
                // get that level's register vector for addition to
                SpellRegisterVector spellRegVec = getSpellRegisterVector(levelOfSpell);
                spellRegVec.addSpell(newSpell);
                noOfSpellsInBook++;
                }
            else {
                JOptionPane.showMessageDialog(null, "That spell already exists!",
                                        "Error: Spell w/ Same Name", JOptionPane.ERROR_MESSAGE);
                }
            }
        else {
            JOptionPane.showMessageDialog(null, "Maximum number of spells already in book!",
                                        "Error: Max No. Spells Reached", JOptionPane.ERROR_MESSAGE);
            }
        }

    // might need to rework the SpellRegister creation
    public void removeSpellRecord(SpellRecord rmSpell) {
        // determine level of spell
        int levelOfSpell = rmSpell.getLevel();
        // traverse Enumeration finding spell
        // delete that element from vector (might do above)
        Vector spellVector = getSpellRecordVector(levelOfSpell);
        if (!spellVector.removeElement(rmSpell)) {
            // JOptionPane: it didn't work!
            JOptionPane.showMessageDialog(null, "The spell was not deleted!",
                                        "Error: Spell Not Deleted", JOptionPane.ERROR_MESSAGE);
            }
        // deletion from register
        SpellRegisterVector spellRegVec = getSpellRegisterVector(levelOfSpell);
        spellRegVec.removeSpell(rmSpell);
        // decrement counter
        noOfSpellsInBook--;
        }

    public SpellRecord findSpellByName(String name) {
        Enumeration e;
        for (int i=0; i < 9; i++) {
            e = getSpellRecordVectorByIndex(i).elements();
            SpellRecord spellRec = new SpellRecord();
            while (e.hasMoreElements()) {
                spellRec = (SpellRecord)e.nextElement();
                if (name.compareTo(spellRec.getName()) == 0) {
                    return spellRec;
                    }
                }
            }
        // this point in the code i reached only if the rec is not found
        return new SpellRecord();
        }

    public SpellRecord findSpell(String name, int level) {
        Enumeration e = getSpellRecordVectorByIndex(level-1).elements();
        SpellRecord spellRec = new SpellRecord();
        while(e.hasMoreElements()) {
            spellRec = (SpellRecord)e.nextElement();
            if (name.compareTo(spellRec.getName()) == 0) {
                return spellRec;
                }
            }
        // this point in the code i reached only if the rec is not found
        return new SpellRecord();
        }

    }